

<html>
<head>
<meta charset="utf-8">	
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<!-- head -->
<script type="text/javascript"  src="/static_base/vue2.6.14.js"></script>
<script src="/static_base/element_ui_2.0.3_index.js"></script><link href="/static_base/element_ui.css" rel="stylesheet">
<script type="text/javascript"  src="/static_base/base.js"></script>
<link rel="stylesheet" href="/static_base/iconfont.css">
<link rel="stylesheet" href="/static_base/base.css">
<script type="text/javascript"  src="/static_base/default.js"></script>
<script type="text/javascript"  src="/static_base/js-md5.js"></script>
<link rel="stylesheet" href="/static_base/default.css">
<link href="\static_base\vuetify2.6.4.min.css" rel="stylesheet">


<script type="text/javascript"  src="\static_base\vuetify2.6.4.js"></script>
<style>
body {
font-family: Arial, sans-serif;
margin: 0;
padding: 0;
background-color: #2d2d2d;
color: #ffffff;
}
.el-button{

color: #409EFF;
 background-color: white!important;
 border-color: #409EFF;
}
.el-button:hover{

 background-color: #409EFF!important ;
 color:white;
 border-color: #409EFF;
}
.el-button:focus {  
color: #409EFF;
 background-color: white!important;
 border-color: #409EFF;
}
</style>
</head>

<body oncontextmenu="return false;">
   <div id="rr"   style="width:100%;height:100%;overflow: hidden;">
    <a_1_0_0_0_0 :deepcopy_data="容器上">
        <a_1_0_1_0_0 :deepcopy_data="菜单栏"></a_1_0_1_0_0>
        <a_1_0_1_2_0 :deepcopy_data="项目名"></a_1_0_1_2_0>
        <a_1_0_1_3_0 :deepcopy_data="用户与菜单"></a_1_0_1_3_0>
    </a_1_0_0_0_0>
    <a_1_0_0_0_0 :deepcopy_data="容器中">
      <a_1_0_0_0_0 style="height:100%; display: block;" :deepcopy_data="主侧栏"> 
         <a_1_0_1_1_0 :deepcopy_data="活动栏"></a_1_0_1_1_0>
         <a_1_0_0_1_0 :deepcopy_data="主侧栏内容">
            <a_1_0_2_0_0 :deepcopy_data="数据库_主侧栏"></a_1_0_2_0_0>
            <a_1_0_2_0_0 :deepcopy_data="前端_主侧栏"></a_1_0_2_0_0>
            <a_1_0_2_0_0 :deepcopy_data="后端_主侧栏"></a_1_0_2_0_0>
            <a_1_0_2_0_0 :deepcopy_data="组件库_主侧栏"></a_1_0_2_0_0>
         </a_1_0_0_1_0>
      
      </a_1_0_0_0_0>
      <a_1_0_0_2_0 :deepcopy_data="编辑栏">
         <a_1_0_3_2_0 :deepcopy_data="前端组件库_编辑栏"></a_1_0_3_2_0>
         <a_1_0_3_3_0 :deepcopy_data="后端组件库_编辑栏"></a_1_0_3_3_0>
         <a_1_0_4_1_1 :deepcopy_data="后端流程可视化编辑界面"></a_1_0_4_1_1>
         <a_1_0_4_5_1 :deepcopy_data="前端可视化编辑界面"></a_1_0_4_5_1>
      </a_1_0_0_2_0>
   </a_1_0_0_0_0>
   <a_1_0_0_3_1 :deepcopy_data="浮动属性栏窗口">
      <a_1_0_4_3_1 :deepcopy_data="后端连线属性窗口"></a_1_0_4_3_1>
      <a_1_0_4_4_1 :deepcopy_data="后端组件属性窗口"></a_1_0_4_4_1>
      <a_1_0_4_6_1 :deepcopy_data="前端组件属性编辑框"></a_1_0_4_6_1>
   </a_1_0_0_3_1>
   </div>
</body>
<script >
   
window.__loading_func=function(){
   let _this=this;
   _this.t=new Date().getTime();
   _this.load_obj= Vue.prototype.$loading({
         lock: true,
         text: '加载中...',
         spinner: 'el-icon-loading',
         background: 'rgba(0, 0, 0, 0.7)'
      });
   _this.load_obj_flag=false;
   
   _this.close=function(){
      _this.load_obj.close();//删除加载标签
   }
   _this.show=function(){
      if((new Date().getTime()-_this.t>900) &&(_this.load_obj_flag==false)){
         _this.load_obj_flag=true;
         _this.close();
         _this.load_obj= Vue.prototype.$loading({
         lock: true,
         text: '服务端正在解析配置文件,并将解析数据加载至内存中...',
         spinner: 'el-icon-loading',
         background: 'rgba(0, 0, 0, 0.7)'
      });
      }
   }
}
window.__loading_func_obj=new window.__loading_func();
(async () => {  

window.help_func=function(){
   console.log("全局配置数据:【 ","全局配置对象.update_obj.data 】",全局配置对象.update_obj.data);
   console.log("主侧栏-数据库:【 ","数据库_主侧栏 】",数据库_主侧栏);
   console.log("主侧栏-前端:【 ","前端_主侧栏 】",前端_主侧栏);
   console.log("主侧栏-后端:【 ","后端_主侧栏 】",后端_主侧栏);
   console.log("主侧栏-组件库:【 ","组件库_主侧栏 】",组件库_主侧栏);

   console.log("前端可视化编辑界面:【 ","前端可视化编辑界面 】",前端可视化编辑界面);
   console.log("前端指定页面组件一览:【 全局配置对象.update_obj.data.page_config.dict[1].dict[1].dict[1].dict 】",全局配置对象.update_obj.data.page_config.dict[1].dict[1].dict[1].dict)
   console.log("后端流程可视化编辑界面:【 ","后端流程可视化编辑界面 】",后端流程可视化编辑界面);

   console.log('前端可视化编辑界面 ALL组件\n\t访问方式:前端可视化编辑界面.return_this().now_dom_dct\n\t数据预览:',前端可视化编辑界面.return_this().now_dom_dct);
   
   console.log('前端组件属性编辑框 ALL编辑项');
   console.log('\t访问方式[数据结构]:前端组件属性编辑框.return_this().old_dict_vue.$refs.ref_obj.data.解析后的数据结构\n\t数据预览:',前端组件属性编辑框.return_this().old_dict_vue.$refs.ref_obj.data.解析后的数据结构);
   console.log('\t访问方式[数据内容]:前端组件属性编辑框.return_this().old_dict_vue.$refs.ref_obj.data.解析后的数据\n\t数据预览:',前端组件属性编辑框.return_this().old_dict_vue.$refs.ref_obj.data.解析后的数据);
   
}

window.vuetify=new Vuetify();
// 使用 Object.defineProperty 来定义 window.help 的 getter
Object.defineProperty(window, 'help', {
get: function() {return help_func();},
configurable: true, // 允许以后使用 Object.defineProperty 修改这个属性
enumerable: true    // 允许这个属性在 for...in 循环中被枚举
});


/* ---------------------前置js-------start--------------*/
//初始化websocket 全局配置对象
    //初始化 全局配置对象
    window.全局配置对象 = new up_ws_class2(['getQueryParams']); 
    //打开日志提示 
    全局配置对象.log_flag=true;
    //等待 建立websocket连接完成
    await 全局配置对象.connect();
    //等待连接完成
    while(1){await time_sleep(0.1);console.log("连接中");
if(全局配置对象.update_obj.connect_flag==true){break;}}
    //获取所有配置
    全局配置对象.初始化();
    //等待获取所有配置完成
    let time_sleep_count=0;
    while(1){await time_sleep(1);window.__loading_func_obj.show();time_sleep_count++;if(time_sleep_count>5000){
      throw new Error("获取配置失败."); }if(time_sleep_count%1000==0){console.log("获取配置中");
}if(全局配置对象.update_obj.get_all_flag==true){break;}}
// await time_sleep(1000000);
window.__loading_func_obj.close();//删除加载标签
    //打印测试
    console.log("全局配置对象.update_obj.data",全局配置对象.update_obj.data);
   //初始化 全局界面监听对象1  初始化浏览器界面监听对象
   window['全局界面监听对象1']=new addcallback();
   
   window.page_size_listen_obj=new page_size_listen_class();
   //浮动窗口当前显示
   window['浮动窗口当前显示']=new addcallback();
   //初始化 全局鼠标操作对象1
   window.全局鼠标操作对象1=new a_move_class();
window.组件库_主侧栏_url={

  获取用户的前端组件库目录1列表_url:'/get_ui_dir1',
  添加前端目录1_url:'/add_ui_dir1',

  获取用户的前端组件库目录2列表_url:'/get_ui_dir2',
  添加前端目录2_url:'/add_ui_dir2',
  修改前端目录1属性_url:'/change_ui_dir1',

  获取用户的前端组件库组件列表_url:'/get_ui_temp',
  添加前端组件_url:'/add_ui_temp',
  修改前端目录2属性_url:'/change_ui_dir2',

  获取用户的前端组件库组件版本列表_url:'/get_ui_version',
  添加前端组件版本_url:'/add_ui_version',
  修改前端组件属性_url:'/change_ui_temp',
  
  修改前端组件版本属性_url:'/change_ui_version',
  更新前端组件版本代码_url:'/update_ui_code',

  下载用户的前端组件库组件版本_url:"/download_ui_code",



   获取用户的后端组件库目录1列表_url:'/get_flow_dir1',
   添加后端目录1_url:'/add_flow_dir1',

   获取用户的后端组件库目录2列表_url:'/get_flow_dir2',
   添加后端目录2_url:'/add_flow_dir2',
   修改后端目录1属性_url:'/change_flow_dir1',

   获取用户的后端组件库组件列表_url:'/get_flow_temp',
   添加后端组件_url:'/add_flow_temp',
   修改后端目录2属性_url:'/change_flow_dir2',

   获取用户的后端组件库组件版本列表_url:'/get_flow_version',
   添加后端组件版本_url:'/add_flow_version',
   修改后端组件属性_url:'/change_flow_temp',

   修改后端组件版本属性_url:'/change_flow_version',
   更新后端组件版本代码_url:'/update_flow_code',

   下载用户的后端组件库组件版本_url:"/download_flow_code",
   
}


window.数据库_主侧栏_url={
   复制建表结构_url:"/db_create_info"
}

window.后端_主侧栏_url={
   粘贴后端目录1_url:'/paste_flow_dir1',
   粘贴后端目录2_url:'/paste_flow_dir2',
   粘贴后端组件_url:'/paste_flow_temp',
   修改后端组件版本_url:'/change_use_flow_version'
}


window.前端_主侧栏_url={
   粘贴前端目录1_url:'/paste_page_dir1',
   粘贴前端目录2_url:'/paste_page_dir2',
   粘贴前端组件_url:'/paste_page_temp',
   修改前端组件版本_url:'/change_use_page_version'
}










let 创建数据库测试数据=function(num=3000){
   let create_new=function(id_,name){
   res={};
   res[id_]={
                                 "base_info":{
                                    "vue_name":"a_1_0_2_0_0_lines",
                                    "deepcopy_data":{"name":`${name}`}
                                 },
                                 "dict":{

                                 }
                              }
   return res
}
let base={'base_info':{},dict:{}};
lhp_deepcopy1(base.dict,create_new("1","数据库列表"));
lhp_deepcopy1(base.dict,create_new("2","搜索"));
// console.log("base",base)
let t=[];
for(let i=0;i<num;i++){
   t.push(i+1+'');
   lhp_deepcopy1(base.dict['1'].dict,create_new(i+'',"用户数据库"+i));
   // lhp_deepcopy1(base.dict['1'].dict,create_new(i+1+'',"日志数据库"+(i+1)));
   lhp_deepcopy1(base.dict['1'].dict[i+''].dict,create_new("1","字段编辑"));
   for (let j=0;j<3;j++){
      lhp_deepcopy1(base.dict['1'].dict[i+''].dict['1'].dict,create_new(j+'',"字段"+j));
   }
   // i++;
}
console.log("??")
return base;
}
let 创建前端测试数据=function(num=3000){
   let create_new=function(id_,name){
   res={};
   res[id_]={
                                 "base_info":{
                                    "vue_name":"a_1_0_2_0_0_lines",
                                    "deepcopy_data":{"name":`${name}`}
                                 },
                                 "dict":{}
                              }
   return res
}
let base={'base_info':{},dict:{}};
lhp_deepcopy1(base.dict,create_new("1","页面列表"));
lhp_deepcopy1(base.dict,create_new("2","拖拽组件"));
lhp_deepcopy1(base.dict['2'].dict,create_new(1,"基础组件"));
lhp_deepcopy1(base.dict['2'].dict[1].dict,create_new("1","图标组件"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("1","表格"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("2","柱状图"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("3","条形图"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("4","饼图"));
lhp_deepcopy1(base.dict['2'].dict[1].dict,create_new("2","控件组件"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[2].dict,create_new("1","文本框"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[2].dict,create_new("2","输入框"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[2].dict,create_new("3","按钮"));
lhp_deepcopy1(base.dict,create_new("3","图片"));
lhp_deepcopy1(base.dict,create_new("4","搜索"));
lhp_deepcopy1(base.dict['4'].dict,create_new(1,"搜索页面库"));
return base
}
let 创建后端测试数据=function(num=3000){
   let create_new=function(id_,name){
   res={};
   res[id_]={
                                 "base_info":{
                                    "vue_name":"a_1_0_2_0_0_lines",
                                    "deepcopy_data":{"name":`${name}`}
                                 },
                                 "dict":{}
                              }
   return res
}
let base={'base_info':{},dict:{}};
lhp_deepcopy1(base.dict,create_new("1","流程图列表"));
lhp_deepcopy1(base.dict,create_new("2","拖拽组件"));
lhp_deepcopy1(base.dict['2'].dict,create_new(1,"基础组件"));
lhp_deepcopy1(base.dict['2'].dict[1].dict,create_new("1","http通信"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("1","http服务"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("2","http收"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("3","http回"));
lhp_deepcopy1(base.dict['2'].dict[1].dict[1].dict,create_new("4","http发"));
lhp_deepcopy1(base.dict,create_new("3","搜索"));
return base;
}
let 创建组件库数据=function(num=3000){return {
            'base_info':{"index":3,},"dict":{
            "1":{
                "base_info":{
                        "vue_name":"a_1_0_2_0_0_lines",
                        "index":0,
                        "deepcopy_data":{"name":'我的组件库'}
                        },
                "dict":{
                    "1":{
                            "base_info":{
                                    "vue_name":"a_1_0_2_1_0",
                                    "index":0,
                                    "deepcopy_data":{"name":'我的前端组件库'}
                                    },
                            "dict":{}
                        },
                    "2":{
                            "base_info":{
                                    "vue_name":"a_1_0_2_8_1",
                                    "index":0,
                                    "deepcopy_data":{"name":'我的后端组件库 '}
                                    },
                            "dict":{}
                        },
                    }
            },
            "2":{
                "base_info":{
                        "vue_name":"a_1_0_2_0_0_lines",
                        "index":0,
                        "deepcopy_data":{"name":'共享组件库'}
                        },
                "dict":{
                    
                    "1":{
                                 
                            "base_info":{
                                    "index":0,
                                    "vue_name":"a_1_0_2_0_0_lines",
                                    "deepcopy_data":{"name":'共享前端组件库',"icon1_show_flag":false,"click_obj":{'func':"全局界面监听对象1.set",'args':['前端组件库_编辑栏']}}
                                    },
                            "dict":{}
                        },
                    "2":{
                            "base_info":{
                                    "index":0,
                                    "vue_name":"a_1_0_2_0_0_lines",
                                    "deepcopy_data":{"name":'共享后端组件库',"icon1_show_flag":false,"click_obj":{'func':"全局界面监听对象1.set",'args':['后端组件库_编辑栏']}}
                                    },
                            "dict":{}
                        },
                    }
                },
            "3":{
                "base_info":{
                        "vue_name":"a_1_0_2_0_0_lines",
                        "index":0,
                        "deepcopy_data":{"name":'搜索'}
                        },
                "dict":{}
            },
            },
            
        }
}
创建前端组件库测试数据=function(){

   let item={
            show_imgsrc:"/static_base/python.png",
            "show_text1":"用户1-基础组件-控件",
            "show_text2":"文本显示框(a0)",
        }
        let lst=[];
        for (let i=0;i<100;i++){
            lst.push(JSON.parse(JSON.stringify(item)));
        }
   return lst
}
let 显示后端流程可视化编辑界面=function(){
   lhp_run_func("全局界面监听对象1.set",'后端流程可视化编辑界面')
}
let 显示前端可视化编辑界面=function(){
   lhp_run_func("全局界面监听对象1.set",'前端可视化编辑界面')
}
new Vue({el:'#rr',
         data: {
            容器上:{var_name:"容器上",更新高度:page_size_listen_obj.注册({key_name:"容器上",name:"布局空间1",change_name:"height",change_func:'容器上.change_height',val:'35px'}),},
            容器中:{var_name:"容器中",更新高度:page_size_listen_obj.注册({key_name:"容器中",name:"布局空间1",change_name:"height",change_func:'容器中.change_height',val:'{height} - {容器上}'}),},
            主侧栏:{var_name:"主侧栏",更新宽度:page_size_listen_obj.注册({key_name:"主侧栏",name:"布局空间2",change_name:"width",change_func:'主侧栏.change_width',val:'22%'}),},
            编辑栏:{var_name:"编辑栏",更新宽度:page_size_listen_obj.注册({key_name:"编辑栏",name:"布局空间2",change_name:"width",change_func:'编辑栏.change_width',val:'100% - {主侧栏}'}),},


            浮动属性栏窗口:{var_name:"浮动属性栏窗口",全局鼠标操作对象1:全局鼠标操作对象1,},
            后端连线属性窗口:{var_name:"后端连线属性窗口",全局配置对象:全局配置对象},
            后端组件属性窗口:{var_name:"后端组件属性窗口",全局配置对象:全局配置对象},
            前端组件属性编辑框:{var_name:"前端组件属性编辑框",全局配置对象:全局配置对象},
            菜单栏:{"var_name":"菜单栏"},
            活动栏:{"var_name":"活动栏"},
            项目名:{"var_name":"项目名"},
            快速选择栏:{"var_name":"快速选择栏"},
            用户与菜单:{"var_name":"用户与菜单"},
            主侧栏内容:{"var_name":"主侧栏内容"},
            // 数据库_主侧栏:{"var_name":"数据库_主侧栏",show_flag:false,data:创建数据库测试数据(83)},
            数据库_主侧栏:{"var_name":"数据库_主侧栏",show_flag:false,
            
            config_name:"db_config",
            tree_data:{
               url:数据库_主侧栏_url,
               全局配置对象:全局配置对象,}
         
         },
            前端_主侧栏:{"var_name":"前端_主侧栏",show_flag:false,
            tree_data:{
               url:前端_主侧栏_url,
               全局鼠标操作对象1:全局鼠标操作对象1,
               全局配置对象:全局配置对象,
            
               "选择页面_onclick":[
               {'func':显示前端可视化编辑界面},
               {'func':"前端可视化编辑界面.set_key"},]
            },
            
            config_name:"page_config",
            data:{}},
            后端_主侧栏:{"var_name":"后端_主侧栏",
               config_name:"flow_chat_config",
            tree_data:{
               url:后端_主侧栏_url,
               全局鼠标操作对象1:全局鼠标操作对象1,
               全局配置对象:全局配置对象,
            "选择流程_onclick":[
            {'func':显示后端流程可视化编辑界面},
            {'func':"后端流程可视化编辑界面.set_key"},]
            },show_flag:false,data:{}},
            组件库_主侧栏:{"var_name":"组件库_主侧栏",tree_data:{url:组件库_主侧栏_url},show_flag:false,data:创建组件库数据(83)},
            前端组件库_编辑栏:{"var_name":"前端组件库_编辑栏",
            show_flag:false,
            'url':"/select_temp1"},
            后端组件库_编辑栏:{"var_name":"后端组件库_编辑栏",
            show_flag:false,
            'url':"/select_temp2"},
            后端流程可视化编辑界面:{"var_name":"后端流程可视化编辑界面",
            
            全局鼠标操作对象1:全局鼠标操作对象1,
            
            全局配置对象:全局配置对象,show_flag:false},
            前端可视化编辑界面:{"var_name":"前端可视化编辑界面",
            全局鼠标操作对象1:全局鼠标操作对象1,
            全局配置对象:全局配置对象,show_flag:false},
            
         },
         mounted:function(){
      this.渲染完成开始js=function(){
        //创建一个浏览器尺寸监听对象
      //   window.page_size_listen_class_listen_dct={};//{id:{"callback":func}}
      //   function page_size_listen_class() {}  
      //   page_size_listen_class.prototype.listen_func = function(){
      //       const width = window.innerWidth;  
      //       const height = window.innerHeight;  
      //       for (let id_ in page_size_listen_class_listen_dct){
      //           // console.log(id_,page_size_listen_class_listen_dct)
      //           try{page_size_listen_class_listen_dct[id_].callback({"width":width,"height":height})}
      //           catch{}
      //       }
      //   };  
      //   page_size_listen_class.prototype.set_listen = function(obj){
      //       let id_=obj.id;
      //       let callback=obj.callback;
      //       window.page_size_listen_class_listen_dct[id_]={callback:callback}
      //       const width = window.innerWidth;  
      //       const height = window.innerHeight;  
      //       try{callback({"width":width,"height":height})}catch{}
      //   };  
      //   window.page_size_listen_obj = new page_size_listen_class();  
  
         // 添加resize事件监听器  
         // window.addEventListener('resize', page_size_listen_obj.listen_func);  
      }
      this.菜单栏设置=function(){


      let save_project=request______({method:'post',url:'/save_project'});
      let getQueryParams=function () {  
         const queryParams = {};  
         const urlParams = new URLSearchParams(window.location.search);  
         for (const [key, value] of urlParams.entries()) {  
            queryParams[key] = value;  
         }  
         return queryParams;  
      }  
      let params=getQueryParams();


        window['菜单栏'].set_menu({
            menu_id:0,
            menu_name:'项目'                                      
         })
         window['菜单栏'].set_item({
            menu_id:0,
            item_id:0,
            item_name:"保存项目",
            item_callback:function(){
               save_project({body_data:params,}
               );
               console.log("保存项目");
}
         })
         window['菜单栏'].set_menu({
            menu_id:1,
            menu_name:'帮助'                                      
         })
         window['菜单栏'].set_item({
            menu_id:1,
            item_id:0,
            item_name:"关于33"
         })
         window['菜单栏'].set_item({
            menu_id:1,
            item_id:0,
            item_name:"关于版本"
         })
         window['菜单栏'].set_item({
            menu_id:1,
            item_id:1,
            item_name:"使用说明"
         })
         window['菜单栏'].set_item({
            menu_id:1,
            item_id:2,
            item_name:"联系作者"
         })
      }
      this.活动栏设置=function(){
        window['活动栏'].set_menu({
        menu_id:0,
        menu_name:'数据库',
        menu_class:'icon iconfont icon-shujuku',
        var_name:'数据库_主侧栏',       
         })
         window['活动栏'].set_menu({
        menu_id:1,
        menu_name:'前端',
        menu_class:'icon iconfont icon-qianduan',    
        var_name:'前端_主侧栏',                          
         })
         window['活动栏'].set_menu({
        menu_id:2,
        menu_name:'后端',
        menu_class:'icon iconfont icon-houduan',     
        var_name:'后端_主侧栏',                         
         })
         window['活动栏'].set_menu({
        menu_id:3,
        menu_name:'组件库',
        menu_class:'icon iconfont icon-zujianku', 
        var_name:'组件库_主侧栏',                             
         })
      }; 
      this.项目名设置=function(){
        window['项目名'].set_project({
            user_id:"0",
            dir1_id:"0",
            temp_id:"0",
            project_name:"测试项目"
        })
      }

//       this.容器高宽设置=function(){
//    容器上.更新高度=page_size_listen_obj.注册({key_name:"容器上",name:"布局空间1",change_name:"height",change_func:'容器上.change_height',val:'35px'});
//    容器中.更新高度=page_size_listen_obj.注册({key_name:"容器中",name:"布局空间1",change_name:"height",change_func:'容器中.change_height',val:'height - {容器上}'});
//    主侧栏.更新宽度=page_size_listen_obj.注册({key_name:"主侧栏",name:"布局空间2",change_name:"width",change_func:'主侧栏.change_width',val:'20%'});
//    编辑栏.更新宽度=page_size_listen_obj.注册({key_name:"编辑栏",name:"布局空间2",change_name:"width",change_func:'编辑栏.change_width',val:'100% - {主侧栏}'});
// }
      // this.主侧栏设置=function(){
      //   page_size_listen_obj.set_listen({'id':4,callback:window['主侧栏'].change_size});
      // }
      // this.容器中=function(){
      
      //   page_size_listen_obj.set_listen({'id':5,callback:window['容器中'].change_size});
      // }
      this.数据库_主侧栏=function(){
         
         // window['数据库_主侧栏'].open("");//初始化
         // 数据库_主侧栏
      }
      this.前端组件库设置=function(){
         全局界面监听对象1.add({
            key:'前端组件库_编辑栏',
            __this__:window['前端组件库_编辑栏'],
            set_name:"show_flag"
         })
      }
      this.后端组件库设置=function(){
         全局界面监听对象1.add({
            key:'后端组件库_编辑栏',
            __this__:window['后端组件库_编辑栏'],
            set_name:"show_flag"
         });


         //绑定主侧栏-
      }
      this.数据库_主侧栏设置=function(){
        //绑定websocket 【websocket 用于协同操作 一个用户更新数据 同步到所有用户当前编辑面板上

        
        全局配置对象.注册(
        obj_data={
          _this:数据库_主侧栏.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'db_config',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          lhp_set1:true,//触发协同数据更改时 不保存数据到vname
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            数据库_主侧栏.add_open_dict_and_open(ee);
            console.log("数据库_主侧栏 接收数据完成",数据库_主侧栏.data)
          }
        })
        数据库_主侧栏.更新函数=全局配置对象.更新;
      }
      this.前端_主侧栏设置=function(){
        //绑定websocket 【websocket 用于协同操作 一个用户更新数据 同步到所有用户当前编辑面板上
        全局配置对象.注册(
        obj_data={
          _this:前端_主侧栏.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'page_config',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            let d=new Date().getTime();
            前端_主侧栏.add_open_dict_and_open(ee);
            console.log("接收数据完成",前端_主侧栏.data);
            console.log("前端主侧栏处理耗时1:",(new Date().getTime()-d)/1000)
            console.log("前端主侧栏处理耗时2:",(new Date().getTime()-window.上传服务器时间)/1000)
          }
        }   )
        前端_主侧栏.更新函数=全局配置对象.更新;
      }
      
      this.后端_主侧栏设置=function(){
        //绑定websocket 【websocket 用于协同操作 一个用户更新数据 同步到所有用户当前编辑面板上
        全局配置对象.注册(
        obj_data={
          _this:后端_主侧栏.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'flow_chat_config',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          lhp_set1:true,//触发协同数据更改时 不保存数据到vname
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            后端_主侧栏.add_open_dict_and_open(ee);
            console.log("后端_主侧栏 接收数据完成",后端_主侧栏.data)
          }
        })
        后端_主侧栏.更新函数=全局配置对象.更新;
      }
      this.组件库_主侧栏设置=function(){
        //绑定websocket 【websocket 用于协同操作 一个用户更新数据 同步到所有用户当前编辑面板上
        // 全局配置对象.注册(
        // obj_data={
        //   _this:组件库_主侧栏.return_this(),//vue对象
        //   other_callback:{},//其他监听回调
        //   path:'template_config',//注册路径 /将此数据绑定到组件上
        //   type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
        //   vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
        //   func:function(){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
        //     console.log("接收数据完成",组件库_主侧栏.data)
        //   }
        // }   )
        // 组件库
        this.组件库_主侧栏.更新函数=全局配置对象.更新;
      }
      this.后端流程可视化编辑界面设置=function(){
         
         后端流程可视化编辑界面_排队计时器=new wait_run_func_class();
         全局界面监听对象1.add({
            key:'后端流程可视化编辑界面',
            __this__:window['后端流程可视化编辑界面'],
            set_name:"show_flag"
         });
      全局配置对象.注册(
        obj_data={
          _this:后端流程可视化编辑界面.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'flow_chat_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          add_time_func:后端流程可视化编辑界面_排队计时器.timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
          }
        }   )
        全局配置对象.注册(
        obj_data={
          _this:后端流程可视化编辑界面.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'flow_chat_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          lhp_set1:true,//触发协同数据更改时 不保存数据到vname
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            后端流程可视化编辑界面.协同数据处理(ee);
            console.log("后端流程可视化编辑界面 接收数据完成",后端流程可视化编辑界面.data)
          }
        }   )
      
      
      }
      
      this.前端可视化编辑界面设置=function(){
         前端可视化编辑界面_排队计时器=new wait_run_func_class();
         全局界面监听对象1.add({
            key:'前端可视化编辑界面',
            __this__:window['前端可视化编辑界面'],
            set_name:"show_flag"
         });
      全局配置对象.注册(
        obj_data={
          _this:前端可视化编辑界面.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'page_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          add_time_func:前端可视化编辑界面_排队计时器.timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
          }
        }   )
        全局配置对象.注册(
        obj_data={
          _this:前端可视化编辑界面.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'page_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          lhp_set1:true,//触发协同数据更改时 不保存数据到vname
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            前端可视化编辑界面.协同数据处理(ee);
            console.log("前端可视化编辑界面 接收数据完成",前端可视化编辑界面.data)
          }
        }   )
      
      
      }
      this.后端连线属性窗口=function(){
         window['浮动窗口当前显示'].add(
            {
            key:'后端连线属性窗口',
            __this__:window['后端连线属性窗口'],
            set_name:"show_flag"
         }
         );

         
        全局配置对象.注册(
        obj_data={
          _this:后端连线属性窗口.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'flow_chat_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"flow_data",// 将接收的的完整数据保存到   vue对象.data[vname]
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
          }
        }   )
      }
      this.后端组件属性窗口=function(){
         window['浮动窗口当前显示'].add(
            {
            key:'后端组件属性窗口',
            __this__:window['后端组件属性窗口'],
            set_name:"show_flag"
         }
         );

         全局配置对象.注册(
        obj_data={
          _this:后端组件属性窗口.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'flow_chat_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"flow_data",// 将接收的的完整数据保存到   vue对象.data[vname]
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
          }
        }   )
      }
      
      this.前端组件属性编辑框设置=function(){
         window['浮动窗口当前显示'].add(
            {
            key:'前端组件属性编辑框',
            __this__:window['前端组件属性编辑框'],
            set_name:"show_flag"
         }
         );

         全局配置对象.注册(
        obj_data={
          _this:前端组件属性编辑框.return_this(),//vue对象
          other_callback:{},//其他监听回调
          path:'page_config.dict.1',//注册路径 /将此数据绑定到组件上
          type:"try3", // 报错不删除此注册[运行 func报错时不直接删除该注册对象]
          vname:"data",// 将接收的的完整数据保存到   vue对象.data[vname]
          lhp_set1:true,//触发协同数据更改时 不保存数据到vname
          add_time_func:window.a_1_0_2_0_0_timer_start,//将要进行的数据更改 放入计时器 同步进行处理
          func:function(ee){//将接收的的完整数据保存到   vue对象.data[vname]后 要执行的函数
            前端组件属性编辑框.协同数据处理(ee);
            console.log("**前端组件属性编辑框 接收数据完成",后端流程可视化编辑界面.data)
          }
        }   )
      }
      window.设置前端编辑区全屏模式=function(){
         容器上.更新高度("0px");
         容器上.show_flag=false;
         主侧栏.更新宽度("0px");
         主侧栏.show_flag=false;
      }
      window.退出前端编辑区全屏模式=function(){
         容器上.更新高度("35px");
         容器上.show_flag=true;
         主侧栏.更新宽度("20%");
         主侧栏.show_flag=true;
      }
      // 等待 Vue 完成 DOM 更新  
      this.$nextTick(() => {  
        this.渲染完成开始js();
        //菜单栏设置 
        this.菜单栏设置();
        //活动栏设置
        this.活动栏设置();
        this.项目名设置();
      //   this.主侧栏设置();
        this.数据库_主侧栏();
         // this.容器中();
         this.前端组件库设置();
         this.后端组件库设置();
         this.后端流程可视化编辑界面设置();
         this.前端可视化编辑界面设置();

         this.数据库_主侧栏设置();
         this.前端_主侧栏设置();
         this.后端_主侧栏设置();
         this.组件库_主侧栏设置();
         this.后端连线属性窗口();
         this.后端组件属性窗口();
         this.前端组件属性编辑框设置();
        活动栏.选择(0);
        page_size_listen_obj.更新所有设置();
      }); 
        
    } })




    
  })();
</script>
